home *** CD-ROM | disk | FTP | other *** search
/ Mac Power 1997 December / MACPOWER-1997-12.ISO.7z / MACPOWER-1997-12.ISO / AMUG / PROGRAMMING / Raven 1.2.sit / Raven 1.2 / • Extras • / SGI STL / stldebug.h < prev    next >
C/C++ Source or Header  |  1997-06-22  |  11KB  |  334 lines
  1. /*
  2.  *
  3.  * Copyright (c) 1997
  4.  * Moscow Center for SPARC Technology
  5.  *
  6.  * Permission to use, copy, modify, distribute and sell this software
  7.  * and its documentation for any purpose is hereby granted without fee,
  8.  * provided that the above copyright notice appear in all copies and
  9.  * that both that copyright notice and this permission notice appear
  10.  * in supporting documentation.  Moscow Center for SPARC Technology makes no
  11.  * representations about the suitability of this software for any
  12.  * purpose.  It is provided "as is" without express or implied warranty.
  13.  *
  14.  */
  15. #ifndef __SGI_STL_STLDEBUG_H
  16. # define __SGI_STL_STLDEBUG_H
  17.  
  18. # if defined ( __STL_DEBUG )
  19. #include <ZDebug.h>                    // ･･･ﾊJDJ
  20.  
  21. # ifndef __SGI_STL_ITERATOR_H
  22. # include <iterator.h>
  23. # endif
  24. // stderr
  25. # include <stdio.h>
  26. # include <stdlib.h>
  27.  
  28. __BEGIN_STL_NAMESPACE
  29.  
  30. # define __STL_MSG_INVALID_ARGUMENT     "Invalid argument to operation (see operation documentation)"
  31.  
  32. # define __STL_MSG_INVALID_CONTAINER    "Taking an iterator out of destroyed (or otherwise corrupted) container"
  33. # define __STL_MSG_EMPTY_CONTAINER      "Trying to extract an object out from empty container"
  34. # define __STL_MSG_ERASE_PAST_THE_END   "Past-the-end iterator could not be erased"
  35. # define __STL_MSG_OUT_OF_BOUNDS        "Index out of bounds"
  36. # define __STL_MSG_NOT_OWNER            "Container doesn't own the iterator"
  37. # define __STL_MSG_INVALID_ITERATOR     "Uninitialized or invalidated (by mutating operation)"¥
  38.        " iterator used"
  39. # define __STL_MSG_INVALID_LEFTHAND_ITERATOR     "Uninitialized or invalidated (by mutating operation)"¥
  40.        " lefthand iterator in expression"
  41. # define __STL_MSG_INVALID_RIGHTHAND_ITERATOR     "Uninitialized or invalidated (by mutating operation)"¥
  42.        " righthand iterator in expression"
  43. # define __STL_MSG_DIFFERENT_OWNERS     "Iterators used in expression are from different owners"
  44. # define __STL_MSG_NOT_DEREFERENCEABLE  "Iterator could not be dereferenced (past-the-end ?)"
  45. # define __STL_MSG_INVALID_RANGE        "Range [first,last) is invalid"
  46. # define __STL_MSG_NOT_IN_RANGE_1       "Iterator is not in range [first,last)"
  47. # define __STL_MSG_NOT_IN_RANGE_2       "Range [first,last) is not in range [start,finish)"
  48. # define __STL_MSG_INVALID_ADVANCE      "The advance would produce invalid iterator"
  49.  
  50. #if RAVEN            // ･･･ﾊJDJ
  51.     #  define __stl_verbose_check(expr,diagnostic) ((expr) ? true : ¥
  52.     (DEBUGSTR("%s:%d STL error : %s¥n", __FILE__, __LINE__, diagnostic ),false))
  53.  
  54.     #  define __stl_verbose_return(expr,diagnostic) if (!(expr)) { ¥
  55.         DEBUGSTR("%s:%d STL error : %s¥n", __FILE__, __LINE__, diagnostic ); return false; }
  56. #else
  57.     #  define __stl_verbose_check(expr,diagnostic) ((expr) ? true : ¥
  58.     (fprintf(stderr, "%s:%d STL error : %s¥n", __FILE__, __LINE__, diagnostic ),false))
  59.  
  60.     #  define __stl_verbose_return(expr,diagnostic) if (!(expr)) { ¥
  61.         fprintf(stderr, "%s:%d STL error : %s¥n", __FILE__, __LINE__, diagnostic ); return false; }
  62. #endif
  63.  
  64. //============================================================================
  65.  
  66. template <class Iterator>
  67. bool __check_same_owner( const Iterator& i1, const Iterator& i2)
  68. {
  69.     __stl_verbose_return(i1.valid(), __STL_MSG_INVALID_LEFTHAND_ITERATOR);
  70.     __stl_verbose_return(i2.valid(), __STL_MSG_INVALID_RIGHTHAND_ITERATOR);
  71.     __stl_verbose_return(i1.owner()==i2.owner(), __STL_MSG_DIFFERENT_OWNERS);
  72.     return true;
  73. }
  74.  
  75. template <class Iterator>
  76. bool __check_if_owner( const void* owner, const Iterator& it)
  77. {
  78.     const void* owner_ptr = it.owner();
  79.     __stl_verbose_return(owner_ptr!=0, __STL_MSG_INVALID_ITERATOR);
  80.     __stl_verbose_return(owner==owner_ptr, __STL_MSG_NOT_OWNER);
  81.     return true;
  82. }
  83.  
  84. inline bool __check_bounds(int index, int size) 
  85. {
  86.     __stl_verbose_return(index<size, __STL_MSG_OUT_OF_BOUNDS);
  87.     return true;
  88. }
  89.  
  90. //=============================================================
  91.  
  92. template <class SafeIterator>
  93. inline bool  __dereferenceable(const SafeIterator& it) { 
  94.     return it.owner()->dereferenceable(it.get_iterator());
  95. }
  96.  
  97. template <class Iterator>
  98. inline bool __valid_range(const Iterator& i1 ,const Iterator& i2, 
  99.                           random_access_iterator_tag)
  100. { 
  101.     return i1<=i2;
  102. }
  103.  
  104. template <class Iterator>
  105. inline bool __valid_range(const Iterator& i1 ,const Iterator& i2, 
  106.                           bidirectional_iterator_tag)
  107. { 
  108.     // check if comparable
  109.     bool dummy(i1==i2);
  110.     return (dummy==dummy); 
  111. }
  112.  
  113. template <class Iterator>
  114. inline bool __valid_range(const Iterator& i1 ,const Iterator& i2, 
  115.                           forward_iterator_tag)
  116. { 
  117.     // check if comparable
  118.     bool dummy(i1==i2);
  119.     return (dummy==dummy); 
  120. }
  121.  
  122. template <class Iterator>
  123. inline bool __valid_range(const Iterator& i1 ,const Iterator& i2, 
  124.                           input_iterator_tag)
  125. { 
  126.     return false; 
  127. }
  128.  
  129. template <class Iterator>
  130. inline bool __valid_range(const Iterator& i1 ,const Iterator& i2, 
  131.                           output_iterator_tag)
  132. { 
  133.     return false; 
  134. }
  135.  
  136. template <class Iterator>
  137. inline bool __valid_range(const Iterator& i1, const Iterator& i2)
  138. { 
  139.     return __valid_range(i1,i2,iterator_category(i1));
  140. }
  141.  
  142. template <class Iterator>
  143. inline bool __in_range(const Iterator& it, const Iterator& i1, const Iterator& i2)
  144. { 
  145.     return __valid_range(i1,it,iterator_category(i1)) && 
  146.         __valid_range(it,i2,iterator_category(it));
  147. }
  148.  
  149. template <class Iterator>
  150. inline bool __in_range(const Iterator& first, const Iterator& last, 
  151.                        const Iterator& start, const Iterator& finish)
  152. { 
  153.     return __valid_range(first,last,iterator_category(first)) &&
  154.         __valid_range(start,first,iterator_category(first)) && 
  155.         __valid_range(last,finish,iterator_category(last));
  156. }
  157.  
  158. //=============================================================
  159.  
  160. template <class SafeIterator>
  161. bool  __check_dereferenceable(const SafeIterator& it) { 
  162.     __stl_verbose_return(it.valid(), __STL_MSG_INVALID_ITERATOR);
  163.     __stl_verbose_return(__dereferenceable(it), __STL_MSG_NOT_DEREFERENCEABLE);
  164.     return true;
  165. }
  166.  
  167. template <class SafeIterator, class Distance>
  168. bool __check_advance(const SafeIterator& it , Distance n )
  169. { 
  170.     __stl_verbose_return(it.valid(), __STL_MSG_INVALID_ITERATOR);
  171.     __stl_verbose_return(it.owner()->valid_advance(it.get_iterator(),n), 
  172.                          __STL_MSG_INVALID_ADVANCE);
  173.     return true;
  174. }
  175.  
  176. template <class Iterator>
  177. bool __check_range(const Iterator& first, const Iterator& last) {
  178.     __stl_verbose_return(__valid_range(first,last), __STL_MSG_INVALID_RANGE );
  179.     return true;
  180. }
  181.  
  182. template <class Iterator>
  183. bool __check_range(const Iterator& it, 
  184.                    const Iterator& start, const Iterator& finish) {
  185.     __stl_verbose_return(__in_range(it,start, finish), 
  186.                          __STL_MSG_NOT_IN_RANGE_1);
  187.     return true;
  188. }
  189.  
  190. template <class Iterator>
  191. bool __check_range(const Iterator& first, const Iterator& last, 
  192.                    const Iterator& start, const Iterator& finish) {
  193.     __stl_verbose_return(__in_range(first, last, start, finish), 
  194.                          __STL_MSG_NOT_IN_RANGE_2);
  195.     return true;
  196. }
  197. //===============================================================
  198.  
  199. // template <class Container>
  200. class __safe_base {
  201. protected:
  202.     typedef void* owner_ptr;
  203.     typedef __safe_base self;
  204.     typedef self* self_ptr;
  205. public:
  206.     __safe_base(const void* c) : 
  207.         owner_(owner_ptr(c)) {
  208.             attach();
  209.         }
  210.     const self* owner() const { return (const self*)owner_; }
  211.     bool  valid() const               { return owner()!=0; }
  212.     __safe_base(const self& rhs) : owner_(rhs.owner_) {
  213.         attach();
  214.     }
  215.     self& operator=(const self& rhs) {
  216.         if ( owner_ != rhs.owner_ ) {
  217.             detach();
  218.             owner_ = rhs.owner_;
  219.             attach();
  220.         }
  221.         return *this;
  222.     }
  223.     ~__safe_base() {
  224.         detach();
  225.         owner_  = 0;
  226.     }
  227.     void invalidate() { owner_=0; }
  228.     void attach() {
  229.         if (owner()) {
  230.             self* owner_node=(self*)owner();
  231.             __stl_verbose_assert(owner_node->owner()!=0, 
  232.                                  __STL_MSG_INVALID_CONTAINER);
  233.             self* list_begin = owner_node->next_;
  234.             next_=list_begin;
  235.             prev_ = list_begin->prev_;
  236.             (list_begin->prev_)->next_=this;
  237.             list_begin->prev_=this;
  238.         }   
  239.     }
  240.     void detach() {
  241.         if (owner()) {
  242.             prev_->next_ = next_ ;
  243.             next_->prev_ = prev_ ;
  244.             owner_=0;
  245.         }
  246.     }
  247.     self* prev() { return prev_; }
  248.     self* next() { return next_; }
  249.     void safe_init(const void* c) { 
  250.         owner_=owner_ptr(c); 
  251.         next_=prev_=this;
  252.     }
  253.     __safe_base() {}
  254.     // note : must be performed on roots
  255.     void swap_owners(self& x) {
  256.         owner_ptr tmp = owner_;
  257.         self* position;
  258.         for (position = x.next(); 
  259.              position!=&x; position=position->next()) {
  260.             position->owner_ = tmp;
  261.         }
  262.         tmp=x.owner_;
  263.         for (position = next(); 
  264.              position!=this; position=position->next()) {
  265.             position->owner_ = tmp;
  266.         }
  267.         x.owner_=owner_;
  268.         owner_=tmp;
  269.     }
  270.     void invalidate_all() {
  271.         for (__safe_base* position = next(); 
  272.              position!=this; position=position->next()) {
  273.             position->invalidate();
  274.         }
  275.         next_=prev_=this;;
  276.     }
  277.     mutable owner_ptr         owner_;
  278. protected:
  279.     mutable self_ptr          next_;
  280.     mutable self_ptr          prev_; 
  281. };
  282.  
  283. //============================================================
  284.  
  285. // _only_ for randomaccess iterators
  286. template <class Iterator, class SafeIterator>
  287. void __invalidate_range(__safe_base* base, 
  288.                         const Iterator& first,
  289.                         const Iterator& last, const SafeIterator&)
  290. {
  291.     typedef __safe_base* base_ptr;
  292.     typedef SafeIterator* safe_iterator_ptr;
  293.     base_ptr list_root = base;
  294.     for (base_ptr position = list_root->next(); 
  295.          position!=list_root;) {
  296.         if (__in_range(((safe_iterator_ptr)position)->get_iterator(),first,last)) {
  297.             base_ptr remove_position=position;
  298.             position=position->next();
  299.             remove_position->detach();
  300.         }
  301.         else
  302.             position=position->next();
  303.     }
  304. }
  305.  
  306. template <class Iterator, class SafeIterator>
  307. void __invalidate_iterator(__safe_base* base, 
  308.                            const Iterator& it, const SafeIterator&)
  309. {
  310.     typedef __safe_base* base_ptr;
  311.     typedef SafeIterator* safe_iterator_ptr;
  312.     base_ptr list_root = base;
  313.     for (base_ptr position = list_root->next(); 
  314.          position!=list_root;) {
  315.         if (((safe_iterator_ptr)position)->get_iterator()==it) {
  316.             base_ptr remove_position=position;
  317.             position=position->next();
  318.             remove_position->detach();
  319.         }
  320.         else
  321.             position=position->next();
  322.     }
  323. }
  324. //============================================================
  325.  
  326. __END_STL_NAMESPACE
  327.  
  328. # endif /* __STL_DEBUG */
  329.  
  330. #endif
  331.  
  332.  
  333.  
  334.